YES 3.077 H-Termination proof of /home/matraf/haskell/eval_FullyBlown_Fast/List.hs
H-Termination of the given Haskell-Program with start terms could successfully be proven:



HASKELL
  ↳ IFR

mainModule List
  ((union :: [Ordering ->  [Ordering ->  [Ordering]) :: [Ordering ->  [Ordering ->  [Ordering])

module List where
  import qualified Maybe
import qualified Prelude

  deleteBy :: (a  ->  a  ->  Bool ->  a  ->  [a ->  [a]
deleteBy _ _ [] []
deleteBy eq x (y : ys if x `eq` y then ys else y : deleteBy eq x ys

  elem_by :: (a  ->  a  ->  Bool ->  a  ->  [a ->  Bool
elem_by _ _ [] False
elem_by eq y (x : xsx `eq` y || elem_by eq y xs

  nubBy :: (a  ->  a  ->  Bool ->  [a ->  [a]
nubBy eq l 
nubBy' l [] where 
nubBy' [] _ []
nubBy' (y : ysxs 
 | elem_by eq y xs = 
nubBy' ys xs
 | otherwise = 
y : nubBy' ys (y : xs)

  union :: Eq a => [a ->  [a ->  [a]
union unionBy (==)

  unionBy :: (a  ->  a  ->  Bool ->  [a ->  [a ->  [a]
unionBy eq xs ys xs ++ foldl (flip (deleteBy eq)) (nubBy eq ys) xs


module Maybe where
  import qualified List
import qualified Prelude



If Reductions:
The following If expression
if eq x y then ys else y : deleteBy eq x ys

is transformed to
deleteBy0 ys y eq x True = ys
deleteBy0 ys y eq x False = y : deleteBy eq x ys



↳ HASKELL
  ↳ IFR
HASKELL
      ↳ BR

mainModule List
  ((union :: [Ordering ->  [Ordering ->  [Ordering]) :: [Ordering ->  [Ordering ->  [Ordering])

module List where
  import qualified Maybe
import qualified Prelude

  deleteBy :: (a  ->  a  ->  Bool ->  a  ->  [a ->  [a]
deleteBy _ _ [] []
deleteBy eq x (y : ysdeleteBy0 ys y eq x (x `eq` y)

  
deleteBy0 ys y eq x True ys
deleteBy0 ys y eq x False y : deleteBy eq x ys

  elem_by :: (a  ->  a  ->  Bool ->  a  ->  [a ->  Bool
elem_by _ _ [] False
elem_by eq y (x : xsx `eq` y || elem_by eq y xs

  nubBy :: (a  ->  a  ->  Bool ->  [a ->  [a]
nubBy eq l 
nubBy' l [] where 
nubBy' [] _ []
nubBy' (y : ysxs 
 | elem_by eq y xs = 
nubBy' ys xs
 | otherwise = 
y : nubBy' ys (y : xs)

  union :: Eq a => [a ->  [a ->  [a]
union unionBy (==)

  unionBy :: (a  ->  a  ->  Bool ->  [a ->  [a ->  [a]
unionBy eq xs ys xs ++ foldl (flip (deleteBy eq)) (nubBy eq ys) xs


module Maybe where
  import qualified List
import qualified Prelude



Replaced joker patterns by fresh variables and removed binding patterns.

↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
HASKELL
          ↳ COR

mainModule List
  ((union :: [Ordering ->  [Ordering ->  [Ordering]) :: [Ordering ->  [Ordering ->  [Ordering])

module List where
  import qualified Maybe
import qualified Prelude

  deleteBy :: (a  ->  a  ->  Bool ->  a  ->  [a ->  [a]
deleteBy vw vx [] []
deleteBy eq x (y : ysdeleteBy0 ys y eq x (x `eq` y)

  
deleteBy0 ys y eq x True ys
deleteBy0 ys y eq x False y : deleteBy eq x ys

  elem_by :: (a  ->  a  ->  Bool ->  a  ->  [a ->  Bool
elem_by vz wu [] False
elem_by eq y (x : xsx `eq` y || elem_by eq y xs

  nubBy :: (a  ->  a  ->  Bool ->  [a ->  [a]
nubBy eq l 
nubBy' l [] where 
nubBy' [] vy []
nubBy' (y : ysxs 
 | elem_by eq y xs = 
nubBy' ys xs
 | otherwise = 
y : nubBy' ys (y : xs)

  union :: Eq a => [a ->  [a ->  [a]
union unionBy (==)

  unionBy :: (a  ->  a  ->  Bool ->  [a ->  [a ->  [a]
unionBy eq xs ys xs ++ foldl (flip (deleteBy eq)) (nubBy eq ys) xs


module Maybe where
  import qualified List
import qualified Prelude



Cond Reductions:
The following Function with conditions
nubBy' [] vy = []
nubBy' (y : ysxs
 | elem_by eq y xs
 = nubBy' ys xs
 | otherwise
 = y : nubBy' ys (y : xs)

is transformed to
nubBy' [] vy = nubBy'3 [] vy
nubBy' (y : ysxs = nubBy'2 (y : ysxs

nubBy'1 y ys xs True = nubBy' ys xs
nubBy'1 y ys xs False = nubBy'0 y ys xs otherwise

nubBy'0 y ys xs True = y : nubBy' ys (y : xs)

nubBy'2 (y : ysxs = nubBy'1 y ys xs (elem_by eq y xs)

nubBy'3 [] vy = []
nubBy'3 wz xu = nubBy'2 wz xu

The following Function with conditions
undefined 
 | False
 = undefined

is transformed to
undefined  = undefined1

undefined0 True = undefined

undefined1  = undefined0 False



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
HASKELL
              ↳ LetRed

mainModule List
  ((union :: [Ordering ->  [Ordering ->  [Ordering]) :: [Ordering ->  [Ordering ->  [Ordering])

module List where
  import qualified Maybe
import qualified Prelude

  deleteBy :: (a  ->  a  ->  Bool ->  a  ->  [a ->  [a]
deleteBy vw vx [] []
deleteBy eq x (y : ysdeleteBy0 ys y eq x (x `eq` y)

  
deleteBy0 ys y eq x True ys
deleteBy0 ys y eq x False y : deleteBy eq x ys

  elem_by :: (a  ->  a  ->  Bool ->  a  ->  [a ->  Bool
elem_by vz wu [] False
elem_by eq y (x : xsx `eq` y || elem_by eq y xs

  nubBy :: (a  ->  a  ->  Bool ->  [a ->  [a]
nubBy eq l 
nubBy' l [] where 
nubBy' [] vy nubBy'3 [] vy
nubBy' (y : ysxs nubBy'2 (y : ys) xs
nubBy'0 y ys xs True y : nubBy' ys (y : xs)
nubBy'1 y ys xs True nubBy' ys xs
nubBy'1 y ys xs False nubBy'0 y ys xs otherwise
nubBy'2 (y : ysxs nubBy'1 y ys xs (elem_by eq y xs)
nubBy'3 [] vy []
nubBy'3 wz xu nubBy'2 wz xu

  union :: Eq a => [a ->  [a ->  [a]
union unionBy (==)

  unionBy :: (a  ->  a  ->  Bool ->  [a ->  [a ->  [a]
unionBy eq xs ys xs ++ foldl (flip (deleteBy eq)) (nubBy eq ys) xs


module Maybe where
  import qualified List
import qualified Prelude



Let/Where Reductions:
The bindings of the following Let/Where expression
nubBy' l []
where 
nubBy' [] vy = nubBy'3 [] vy
nubBy' (y : ysxs = nubBy'2 (y : ysxs
nubBy'0 y ys xs True = y : nubBy' ys (y : xs)
nubBy'1 y ys xs True = nubBy' ys xs
nubBy'1 y ys xs False = nubBy'0 y ys xs otherwise
nubBy'2 (y : ysxs = nubBy'1 y ys xs (elem_by eq y xs)
nubBy'3 [] vy = []
nubBy'3 wz xu = nubBy'2 wz xu

are unpacked to the following functions on top level
nubByNubBy'2 xv (y : ysxs = nubByNubBy'1 xv y ys xs (elem_by xv y xs)

nubByNubBy'0 xv y ys xs True = y : nubByNubBy' xv ys (y : xs)

nubByNubBy' xv [] vy = nubByNubBy'3 xv [] vy
nubByNubBy' xv (y : ysxs = nubByNubBy'2 xv (y : ysxs

nubByNubBy'3 xv [] vy = []
nubByNubBy'3 xv wz xu = nubByNubBy'2 xv wz xu

nubByNubBy'1 xv y ys xs True = nubByNubBy' xv ys xs
nubByNubBy'1 xv y ys xs False = nubByNubBy'0 xv y ys xs otherwise



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
HASKELL
                  ↳ Narrow

mainModule List
  (union :: [Ordering ->  [Ordering ->  [Ordering])

module List where
  import qualified Maybe
import qualified Prelude

  deleteBy :: (a  ->  a  ->  Bool ->  a  ->  [a ->  [a]
deleteBy vw vx [] []
deleteBy eq x (y : ysdeleteBy0 ys y eq x (x `eq` y)

  
deleteBy0 ys y eq x True ys
deleteBy0 ys y eq x False y : deleteBy eq x ys

  elem_by :: (a  ->  a  ->  Bool ->  a  ->  [a ->  Bool
elem_by vz wu [] False
elem_by eq y (x : xsx `eq` y || elem_by eq y xs

  nubBy :: (a  ->  a  ->  Bool ->  [a ->  [a]
nubBy eq l nubByNubBy' eq l []

  
nubByNubBy' xv [] vy nubByNubBy'3 xv [] vy
nubByNubBy' xv (y : ysxs nubByNubBy'2 xv (y : ys) xs

  
nubByNubBy'0 xv y ys xs True y : nubByNubBy' xv ys (y : xs)

  
nubByNubBy'1 xv y ys xs True nubByNubBy' xv ys xs
nubByNubBy'1 xv y ys xs False nubByNubBy'0 xv y ys xs otherwise

  
nubByNubBy'2 xv (y : ysxs nubByNubBy'1 xv y ys xs (elem_by xv y xs)

  
nubByNubBy'3 xv [] vy []
nubByNubBy'3 xv wz xu nubByNubBy'2 xv wz xu

  union :: Eq a => [a ->  [a ->  [a]
union unionBy (==)

  unionBy :: (a  ->  a  ->  Bool ->  [a ->  [a ->  [a]
unionBy eq xs ys xs ++ foldl (flip (deleteBy eq)) (nubBy eq ys) xs


module Maybe where
  import qualified List
import qualified Prelude



Haskell To QDPs


↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_nubByNubBy'1(xw198, xw199, xw200, xw201, False, [], ba) → new_nubByNubBy'(xw199, xw198, :(xw200, xw201), ba)
new_nubByNubBy'1(xw198, xw199, xw200, xw201, True, xw203, ba) → new_nubByNubBy'(xw199, xw200, xw201, ba)
new_nubByNubBy'1(xw198, xw199, xw200, xw201, False, :(xw2030, xw2031), ba) → new_nubByNubBy'1(xw198, xw199, xw200, xw201, new_esEs(xw2030, xw198, ba), xw2031, ba)
new_nubByNubBy'(:(xw1060, xw1061), xw107, xw108, bb) → new_nubByNubBy'1(xw1060, xw1061, xw107, xw108, new_esEs0(xw107, xw1060, bb), xw108, bb)

The TRS R consists of the following rules:

new_esEs0(xw107, xw1060, app(ty_[], cf)) → new_esEs1(xw107, xw1060, cf)
new_esEs0(xw107, xw1060, ty_Ordering) → new_esEs4(xw107, xw1060)
new_esEs7(xw10, xw90) → error([])
new_esEs(xw2030, xw198, app(ty_[], bc)) → new_esEs1(xw2030, xw198, bc)
new_esEs0(xw107, xw1060, ty_@0) → new_esEs2(xw107, xw1060)
new_esEs4(EQ, LT) → False
new_esEs4(LT, EQ) → False
new_esEs0(xw107, xw1060, app(ty_Maybe, dg)) → new_esEs13(xw107, xw1060, dg)
new_esEs13(xw10, xw90, ea) → error([])
new_esEs(xw2030, xw198, ty_@0) → new_esEs2(xw2030, xw198)
new_esEs(xw2030, xw198, app(ty_Ratio, cd)) → new_esEs14(xw2030, xw198, cd)
new_esEs12(xw10, xw90) → error([])
new_esEs6(xw10, xw90, ec, ed) → error([])
new_esEs0(xw107, xw1060, ty_Bool) → new_esEs9(xw107, xw1060)
new_esEs4(GT, EQ) → False
new_esEs4(EQ, GT) → False
new_esEs(xw2030, xw198, app(app(app(ty_@3, bf), bg), bh)) → new_esEs10(xw2030, xw198, bf, bg, bh)
new_esEs10(xw10, xw90, ee, ef, eg) → error([])
new_esEs4(GT, LT) → False
new_esEs4(LT, GT) → False
new_esEs(xw2030, xw198, ty_Ordering) → new_esEs4(xw2030, xw198)
new_esEs(xw2030, xw198, app(ty_Maybe, cc)) → new_esEs13(xw2030, xw198, cc)
new_esEs14(xw10, xw90, ce) → error([])
new_esEs(xw2030, xw198, ty_Bool) → new_esEs9(xw2030, xw198)
new_esEs(xw2030, xw198, ty_Char) → new_esEs5(xw2030, xw198)
new_esEs0(xw107, xw1060, ty_Double) → new_esEs12(xw107, xw1060)
new_esEs0(xw107, xw1060, app(app(ty_Either, de), df)) → new_esEs11(xw107, xw1060, de, df)
new_esEs(xw2030, xw198, ty_Integer) → new_esEs7(xw2030, xw198)
new_esEs11(xw10, xw90, eh, fa) → error([])
new_esEs(xw2030, xw198, ty_Int) → new_esEs8(xw2030, xw198)
new_esEs0(xw107, xw1060, app(ty_Ratio, dh)) → new_esEs14(xw107, xw1060, dh)
new_esEs0(xw107, xw1060, app(app(ty_@2, cg), da)) → new_esEs6(xw107, xw1060, cg, da)
new_esEs5(xw10, xw90) → error([])
new_esEs2(xw10, xw90) → error([])
new_esEs3(xw10, xw90) → error([])
new_esEs0(xw107, xw1060, app(app(app(ty_@3, db), dc), dd)) → new_esEs10(xw107, xw1060, db, dc, dd)
new_esEs1(xw10, xw90, eb) → error([])
new_esEs(xw2030, xw198, ty_Float) → new_esEs3(xw2030, xw198)
new_esEs0(xw107, xw1060, ty_Char) → new_esEs5(xw107, xw1060)
new_esEs(xw2030, xw198, app(app(ty_Either, ca), cb)) → new_esEs11(xw2030, xw198, ca, cb)
new_esEs0(xw107, xw1060, ty_Integer) → new_esEs7(xw107, xw1060)
new_esEs8(xw10, xw90) → error([])
new_esEs0(xw107, xw1060, ty_Float) → new_esEs3(xw107, xw1060)
new_esEs4(EQ, EQ) → True
new_esEs9(xw10, xw90) → error([])
new_esEs4(GT, GT) → True
new_esEs0(xw107, xw1060, ty_Int) → new_esEs8(xw107, xw1060)
new_esEs(xw2030, xw198, ty_Double) → new_esEs12(xw2030, xw198)
new_esEs(xw2030, xw198, app(app(ty_@2, bd), be)) → new_esEs6(xw2030, xw198, bd, be)
new_esEs4(LT, LT) → True

The set Q consists of the following terms:

new_esEs0(x0, x1, ty_Double)
new_esEs13(x0, x1, x2)
new_esEs14(x0, x1, x2)
new_esEs0(x0, x1, app(app(ty_@2, x2), x3))
new_esEs(x0, x1, ty_Char)
new_esEs0(x0, x1, app(ty_[], x2))
new_esEs0(x0, x1, ty_Char)
new_esEs2(x0, x1)
new_esEs10(x0, x1, x2, x3, x4)
new_esEs(x0, x1, app(ty_Ratio, x2))
new_esEs11(x0, x1, x2, x3)
new_esEs4(GT, LT)
new_esEs4(LT, GT)
new_esEs(x0, x1, ty_Bool)
new_esEs5(x0, x1)
new_esEs0(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs0(x0, x1, app(ty_Maybe, x2))
new_esEs4(LT, LT)
new_esEs0(x0, x1, ty_Integer)
new_esEs(x0, x1, app(app(ty_Either, x2), x3))
new_esEs(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs(x0, x1, ty_Double)
new_esEs0(x0, x1, ty_Bool)
new_esEs12(x0, x1)
new_esEs6(x0, x1, x2, x3)
new_esEs0(x0, x1, ty_Int)
new_esEs4(LT, EQ)
new_esEs4(EQ, LT)
new_esEs1(x0, x1, x2)
new_esEs9(x0, x1)
new_esEs0(x0, x1, ty_Float)
new_esEs(x0, x1, ty_Int)
new_esEs(x0, x1, app(ty_[], x2))
new_esEs8(x0, x1)
new_esEs(x0, x1, ty_Ordering)
new_esEs(x0, x1, ty_@0)
new_esEs(x0, x1, app(app(ty_@2, x2), x3))
new_esEs0(x0, x1, app(ty_Ratio, x2))
new_esEs7(x0, x1)
new_esEs0(x0, x1, ty_@0)
new_esEs(x0, x1, ty_Float)
new_esEs(x0, x1, ty_Integer)
new_esEs0(x0, x1, ty_Ordering)
new_esEs4(EQ, EQ)
new_esEs3(x0, x1)
new_esEs0(x0, x1, app(app(ty_Either, x2), x3))
new_esEs(x0, x1, app(ty_Maybe, x2))
new_esEs4(GT, EQ)
new_esEs4(EQ, GT)
new_esEs4(GT, GT)

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_deleteBy0(xw17, xw18, xw19, False, ba) → new_deleteBy(xw19, xw17, ba)
new_deleteBy(xw10, :(xw90, xw91), bb) → new_deleteBy0(xw91, xw90, xw10, new_esEs15(xw10, xw90, bb), bb)

The TRS R consists of the following rules:

new_esEs11(xw10, xw90, cc, cd) → error([])
new_esEs15(xw10, xw90, app(app(ty_@2, bf), bg)) → new_esEs6(xw10, xw90, bf, bg)
new_esEs5(xw10, xw90) → error([])
new_esEs15(xw10, xw90, ty_Double) → new_esEs12(xw10, xw90)
new_esEs15(xw10, xw90, app(ty_Maybe, bd)) → new_esEs13(xw10, xw90, bd)
new_esEs7(xw10, xw90) → error([])
new_esEs2(xw10, xw90) → error([])
new_esEs4(LT, EQ) → False
new_esEs4(EQ, LT) → False
new_esEs3(xw10, xw90) → error([])
new_esEs15(xw10, xw90, app(ty_Ratio, bc)) → new_esEs14(xw10, xw90, bc)
new_esEs1(xw10, xw90, be) → error([])
new_esEs15(xw10, xw90, ty_Int) → new_esEs8(xw10, xw90)
new_esEs15(xw10, xw90, app(app(ty_Either, cc), cd)) → new_esEs11(xw10, xw90, cc, cd)
new_esEs15(xw10, xw90, ty_Char) → new_esEs5(xw10, xw90)
new_esEs13(xw10, xw90, bd) → error([])
new_esEs8(xw10, xw90) → error([])
new_esEs12(xw10, xw90) → error([])
new_esEs15(xw10, xw90, ty_Bool) → new_esEs9(xw10, xw90)
new_esEs6(xw10, xw90, bf, bg) → error([])
new_esEs15(xw10, xw90, app(app(app(ty_@3, bh), ca), cb)) → new_esEs10(xw10, xw90, bh, ca, cb)
new_esEs4(EQ, GT) → False
new_esEs4(GT, EQ) → False
new_esEs4(EQ, EQ) → True
new_esEs9(xw10, xw90) → error([])
new_esEs10(xw10, xw90, bh, ca, cb) → error([])
new_esEs15(xw10, xw90, ty_Ordering) → new_esEs4(xw10, xw90)
new_esEs4(LT, GT) → False
new_esEs4(GT, LT) → False
new_esEs15(xw10, xw90, ty_Integer) → new_esEs7(xw10, xw90)
new_esEs15(xw10, xw90, ty_@0) → new_esEs2(xw10, xw90)
new_esEs4(GT, GT) → True
new_esEs15(xw10, xw90, ty_Float) → new_esEs3(xw10, xw90)
new_esEs14(xw10, xw90, bc) → error([])
new_esEs15(xw10, xw90, app(ty_[], be)) → new_esEs1(xw10, xw90, be)
new_esEs4(LT, LT) → True

The set Q consists of the following terms:

new_esEs4(LT, EQ)
new_esEs4(EQ, LT)
new_esEs6(x0, x1, x2, x3)
new_esEs14(x0, x1, x2)
new_esEs9(x0, x1)
new_esEs15(x0, x1, app(ty_[], x2))
new_esEs15(x0, x1, app(ty_Maybe, x2))
new_esEs15(x0, x1, ty_Ordering)
new_esEs8(x0, x1)
new_esEs15(x0, x1, ty_Double)
new_esEs15(x0, x1, app(app(ty_@2, x2), x3))
new_esEs7(x0, x1)
new_esEs2(x0, x1)
new_esEs15(x0, x1, ty_@0)
new_esEs1(x0, x1, x2)
new_esEs15(x0, x1, ty_Float)
new_esEs15(x0, x1, app(ty_Ratio, x2))
new_esEs4(LT, GT)
new_esEs4(GT, LT)
new_esEs15(x0, x1, ty_Char)
new_esEs4(EQ, EQ)
new_esEs15(x0, x1, ty_Int)
new_esEs3(x0, x1)
new_esEs5(x0, x1)
new_esEs15(x0, x1, app(app(ty_Either, x2), x3))
new_esEs4(LT, LT)
new_esEs13(x0, x1, x2)
new_esEs4(GT, EQ)
new_esEs4(EQ, GT)
new_esEs10(x0, x1, x2, x3, x4)
new_esEs15(x0, x1, ty_Bool)
new_esEs12(x0, x1)
new_esEs11(x0, x1, x2, x3)
new_esEs15(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs4(GT, GT)
new_esEs15(x0, x1, ty_Integer)

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_foldl(xw9, xw10, :(xw110, xw111), ba) → new_foldl(new_flip(xw9, xw10, ba), xw110, xw111, ba)

The TRS R consists of the following rules:

new_esEs11(xw10, xw90, cc, cd) → error([])
new_esEs15(xw10, xw90, app(app(ty_@2, bf), bg)) → new_esEs6(xw10, xw90, bf, bg)
new_esEs5(xw10, xw90) → error([])
new_esEs15(xw10, xw90, ty_Double) → new_esEs12(xw10, xw90)
new_esEs15(xw10, xw90, app(ty_Maybe, bc)) → new_esEs13(xw10, xw90, bc)
new_esEs7(xw10, xw90) → error([])
new_esEs2(xw10, xw90) → error([])
new_deleteBy00(xw17, xw18, xw19, True, bd) → xw17
new_esEs4(LT, EQ) → False
new_esEs4(EQ, LT) → False
new_esEs3(xw10, xw90) → error([])
new_esEs15(xw10, xw90, app(ty_Ratio, bb)) → new_esEs14(xw10, xw90, bb)
new_esEs1(xw10, xw90, be) → error([])
new_esEs15(xw10, xw90, ty_Int) → new_esEs8(xw10, xw90)
new_esEs15(xw10, xw90, app(app(ty_Either, cc), cd)) → new_esEs11(xw10, xw90, cc, cd)
new_esEs15(xw10, xw90, ty_Char) → new_esEs5(xw10, xw90)
new_esEs13(xw10, xw90, bc) → error([])
new_deleteBy1(xw10, [], ba) → []
new_esEs8(xw10, xw90) → error([])
new_esEs15(xw10, xw90, ty_Bool) → new_esEs9(xw10, xw90)
new_esEs12(xw10, xw90) → error([])
new_esEs15(xw10, xw90, app(app(app(ty_@3, bh), ca), cb)) → new_esEs10(xw10, xw90, bh, ca, cb)
new_esEs6(xw10, xw90, bf, bg) → error([])
new_deleteBy1(xw10, :(xw90, xw91), ba) → new_deleteBy00(xw91, xw90, xw10, new_esEs15(xw10, xw90, ba), ba)
new_esEs4(EQ, GT) → False
new_esEs4(GT, EQ) → False
new_deleteBy00(xw17, xw18, xw19, False, bd) → :(xw18, new_deleteBy1(xw19, xw17, bd))
new_esEs4(EQ, EQ) → True
new_esEs9(xw10, xw90) → error([])
new_esEs10(xw10, xw90, bh, ca, cb) → error([])
new_esEs15(xw10, xw90, ty_Ordering) → new_esEs4(xw10, xw90)
new_esEs4(LT, GT) → False
new_esEs4(GT, LT) → False
new_esEs15(xw10, xw90, ty_Integer) → new_esEs7(xw10, xw90)
new_esEs15(xw10, xw90, ty_@0) → new_esEs2(xw10, xw90)
new_esEs4(GT, GT) → True
new_esEs15(xw10, xw90, ty_Float) → new_esEs3(xw10, xw90)
new_flip(xw9, xw10, ba) → new_deleteBy1(xw10, xw9, ba)
new_esEs14(xw10, xw90, bb) → error([])
new_esEs15(xw10, xw90, app(ty_[], be)) → new_esEs1(xw10, xw90, be)
new_esEs4(LT, LT) → True

The set Q consists of the following terms:

new_deleteBy00(x0, x1, x2, False, x3)
new_esEs4(LT, EQ)
new_esEs4(EQ, LT)
new_deleteBy00(x0, x1, x2, True, x3)
new_esEs6(x0, x1, x2, x3)
new_esEs9(x0, x1)
new_esEs15(x0, x1, app(ty_[], x2))
new_deleteBy1(x0, :(x1, x2), x3)
new_esEs15(x0, x1, ty_Ordering)
new_flip(x0, x1, x2)
new_esEs8(x0, x1)
new_esEs15(x0, x1, ty_Double)
new_esEs15(x0, x1, app(app(ty_@2, x2), x3))
new_esEs7(x0, x1)
new_esEs2(x0, x1)
new_esEs15(x0, x1, ty_@0)
new_esEs1(x0, x1, x2)
new_esEs15(x0, x1, ty_Float)
new_esEs4(LT, GT)
new_esEs4(GT, LT)
new_esEs4(EQ, EQ)
new_esEs15(x0, x1, ty_Char)
new_esEs15(x0, x1, ty_Int)
new_esEs14(x0, x1, x2)
new_esEs3(x0, x1)
new_deleteBy1(x0, [], x1)
new_esEs5(x0, x1)
new_esEs15(x0, x1, app(app(ty_Either, x2), x3))
new_esEs15(x0, x1, app(ty_Maybe, x2))
new_esEs4(LT, LT)
new_esEs4(EQ, GT)
new_esEs4(GT, EQ)
new_esEs10(x0, x1, x2, x3, x4)
new_esEs15(x0, x1, ty_Bool)
new_esEs15(x0, x1, app(ty_Ratio, x2))
new_esEs12(x0, x1)
new_esEs11(x0, x1, x2, x3)
new_esEs15(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs4(GT, GT)
new_esEs15(x0, x1, ty_Integer)
new_esEs13(x0, x1, x2)

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ IFR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
QDP
                        ↳ QDPSizeChangeProof

Q DP problem:
The TRS P consists of the following rules:

new_psPs(:(xw80, xw81), xw9, xw10, xw11, ba) → new_psPs(xw81, xw9, xw10, xw11, ba)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: